home *** CD-ROM | disk | FTP | other *** search
/ PC World Interactive 7 / PC World Interactive 7.iso / program / ctutor.exe / SOURCE / LISTF.C < prev    next >
Encoding:
C/C++ Source or Header  |  1994-05-15  |  10.3 KB  |  250 lines
  1. /*******************************************************************/
  2. /* LISTF.C - working functions for LIST.EXE                        */
  3. /* Copyright (c) 1994 Coronado Enterprises                         */
  4. /*                                                                 */
  5. /* This module contains the functions called by the LIST.C program */
  6. /*  program.  They are very specific to that program rather than   */
  7. /*  being generic in nature, so they are not considered reusable.  */
  8. /*******************************************************************/
  9.  
  10. #include <stdio.h>           /* standard I/O header file           */
  11. #include <string.h>          /* prototypes for strings             */
  12.  
  13.    /* The following group of #include's are not ANSI compatible,   */
  14.    /*  so they may not work with your compiler.  They are a part   */
  15.    /*  of the Microsoft Visual C++ compiler version 1.0. They are  */
  16.    /*  used only in the get_file_date_time function in this file.  */
  17. #include <dos.h>             /* used for get_file_date_time        */
  18. #include <errno.h>           /* used for get_file_date_time        */
  19. #include <fcntl.h>           /* used for get_file_date_time        */
  20. #include <share.h>           /* used for get_file_date_time        */
  21.  
  22. #include "listf.h"           /* custom prototypes                  */
  23. #define MAXLINES 55          /* maximum number of lines per page   */
  24. #define MAXCHARS 255         /* maximum size of a line             */
  25. #define MAXFILENAME 80       /* max length of path and filename    */
  26. #define MAXPRINTLINE 72      /* max characters on one printer line */
  27.  
  28. int  line_number = 1;        /* line number initialized to one     */
  29. int  page_number = 1;        /* page number initialized to one     */
  30. int  lines_this_page = 0;    /* lines on this page so far          */
  31. char oneline[MAXCHARS + 1];  /* input string buffer area           */
  32. char filename[MAXFILENAME + 1];  /* filename from header or prompt */
  33. char file_date_time[50];     /* formatted date and time storage    */
  34. FILE *in_file;               /* pointer to file to be read         */
  35. FILE *printer;               /* pointer to printer                 */
  36.  
  37.  
  38.  
  39. /**************************************************** open_in_file */
  40. /* This function opens the input file named on the command line,   */
  41. /*  if there was one defined.  Otherwise, it requests a file name  */
  42. /*  to open and opens the requested file.  It continues to ask for */
  43. /*  a file name until a valid filename is entered, up to 3 times   */
  44. /*******************************************************************/
  45. int open_in_file(int no, char *name)
  46. {
  47. int index, count;
  48.  
  49.    strcpy(filename, name);     /* copy name for printing header    */
  50.    if (no == 2) {              /* 2nd field in command is filename */
  51.       get_file_date_time();
  52.       in_file = fopen(name, "r");   /* open requested file         */
  53.       if (in_file == NULL)     /* NULL if file doesn't exist       */
  54.          printf("Filename on command line doesn't exist!\n");
  55.       else
  56.          return 0;             /* file opened correctly, return    */
  57.    }
  58.  
  59.    if (in_file == NULL) {      /* filename was not on command line */
  60.          /* Give user three chances to enter a filename, then quit.*/
  61.       for (index = 0 ; index < 3 ; index++) {
  62.          printf("Enter filename -> ");
  63.  
  64.             /* There is no string input with a limited number of   */
  65.             /*  characters, so we must write our own.  This loop   */
  66.             /*  limits number of chars in the input filename.      */
  67.          for (count = 0 ; count <= MAXFILENAME ; count++) {
  68.             filename[count] = getchar(); /* get a char from keybrd */
  69.             if (filename[count] == '\n') {
  70.                filename[count] = 0;
  71.                break;
  72.             }
  73.          }                                                           
  74.                                 /* We must guarantee a terminating */
  75.          filename[count] = 0;   /* null if the loop completes      */
  76.          
  77.          get_file_date_time();
  78.          in_file = fopen(filename, "r"); /* open file              */
  79.          if (in_file == NULL)          /* NULL if file didn't open */
  80.             printf("Filename doesn't exist, try again.\n");
  81.          else
  82.             return 0;       /* input file opened correctly, return */
  83.       }
  84.    } 
  85.    printf("Three times is enough, aborting list program\n");
  86.    return 1;                /* error return, file not opened       */
  87. }
  88.  
  89.  
  90.  
  91. /**************************************************** open_printer */
  92. /* This function opens the printer for ASCII output.               */
  93. /*******************************************************************/
  94. int open_printer(void)
  95. {
  96.    printer = fopen("PRN", "w"); /* open printer file               */
  97.    if (printer == NULL) {
  98.       printf("Printer not ready, aborting list program\n");
  99.       return 1;                 /* error return, printer not ready */
  100.    } else {
  101.       return 0;                 /* return with the printer opened  */
  102.    }
  103. }
  104.  
  105.  
  106.  
  107. /********************************************** get_file_date_time */
  108. /* This is a local function that is only called from inside this   */
  109. /*  file.  It retrieves the date and time from the file under      */
  110. /*  consideration and formats them for the header. It used some    */
  111. /*  functions that are not ANSI compatible so it may be unusable   */
  112. /*  with other compilers.                                          */
  113. /*******************************************************************/
  114. void get_file_date_time(void)
  115. {
  116. int file_handle;
  117. unsigned f_date;
  118. unsigned f_time;
  119. int hour, minute;
  120. int month, day, year;
  121.  
  122.    strcpy(file_date_time, "");     /* blank string if it fails     */
  123.    
  124.    if (_dos_open(filename, _O_RDONLY, &file_handle) == 0)
  125.       _dos_getftime(file_handle, &f_date, &f_time);
  126.  
  127.       hour   = (f_time >> 11) & 0x1f;
  128.       minute = (f_time >> 5)  & 0x3f;
  129.       day    =  f_date        & 0x1f;
  130.       month  = (f_date >> 5)  & 0xf;
  131.       year   = (f_date >> 9)  + 1980;
  132.       sprintf(file_date_time, "%d:%d %d/%d/%d", 
  133.                                      hour, minute, month, day, year);
  134.  
  135.       _dos_close(file_handle);
  136. }
  137.  
  138.  
  139.  
  140. /*************************************************** read_one_line */
  141. /* This routine reads one line of text.  If fgets returns a zero,  */
  142. /*  it has read the entire file, so it returns a value of zero to  */
  143. /*  the calling program.  If fgets returns a valid pointer to the  */
  144. /*  new line of text read in this function returns an int value    */
  145. /*  of 1 to the calling program.                                   */
  146. /*******************************************************************/
  147. int read_one_line(void)
  148. {
  149.    oneline[0] = 0;   /* if nothing is read, this blanks the line   */
  150.    if (fgets(oneline, MAXCHARS, in_file))
  151.       return 1;  /* valid line of text found and stored in oneline */
  152.    else
  153.       return 0;  /* end of file or error condition found, no text  */
  154. }
  155.  
  156.  
  157.  
  158. /***************************************************** top_of_page */
  159. /* This routine checks to see if a header needs to be printed. It  */
  160. /*  also checks for the end of a page and spaces the paper up.     */
  161. /*******************************************************************/
  162. void top_of_page(void)
  163. {
  164. int count;
  165.  
  166.    if (line_number == 1)     /* top of page 1, need a header       */
  167.       ;                      /* continue and let the header print  */
  168.    else {
  169.       if (lines_this_page >= MAXLINES)  /* at bottom of page ?     */
  170.          eject_page();
  171.       else
  172.          return;             /* no action needed, return           */
  173.    }
  174.  
  175.       /* list the filename and page number on the monitor          */
  176.    printf("   Source file %s  Page number %d\n",
  177.                                               filename, page_number);
  178.  
  179.       /* print the header information                              */
  180.       /* count will be set to the number of characters output      */
  181.    count = fprintf(printer, "\n     Source file --> %s   %s", 
  182.                                            filename, file_date_time);
  183.    for (/* count is set */ ; count < 70 ; count++)
  184.       fprintf(printer, " ");       /* print blanks until column 70 */
  185.    fprintf(printer, "Page %d\n\n", page_number);
  186.    page_number++;
  187.    lines_this_page = 0;
  188. }
  189.  
  190.  
  191.  
  192. /************************************************** print_one_line */
  193. /* This routine prints a line of text using a maximum of 72 chars  */
  194. /*  on a line.  Tabs are converted into three spaces, and lines    */
  195. /*  that are too long will have no CR/LF, so one is output.        */
  196. /*******************************************************************/
  197. void print_one_line(void)
  198. {
  199. unsigned index;
  200. unsigned char_count = 0;
  201.  
  202.    fprintf(printer, "%6d ", line_number); /* line number & 1 space */
  203.    
  204.    for (index = 0 ; index < strlen(oneline) ; index++) {
  205.       if (char_count >= MAXPRINTLINE) {  /* if at edge of paper    */
  206.          fprintf(printer, "\n       ");  /* start a new line       */
  207.          lines_this_page++;              /* add to physical lines  */
  208.          char_count = 0;                 /* reset char count       */
  209.       }
  210.       if (oneline[index] == '\t') {      /* if it is a tab         */
  211.          fprintf(printer, "   ");        /* print 3 spaces         */
  212.          char_count += 3;
  213.       } else {
  214.          fprintf(printer, "%c", oneline[index]);
  215.          char_count++;
  216.       }
  217.    }
  218.  
  219.          /* this outputs a newline if there is not one in the line */
  220.    if (oneline[strlen(oneline) - 1] != '\n')
  221.       fprintf(printer, "%c", '\n');
  222.       
  223.    lines_this_page++;   
  224.    line_number++;
  225. }
  226.  
  227.  
  228.  
  229. /****************************************************** eject_page */
  230. /* This routine ejects the page and sets the current page line     */
  231. /*  count to zero.                                                 */
  232. /*******************************************************************/
  233. void eject_page(void)
  234. {
  235. const int FF = 12;    /* 12 = formfeed character                   */
  236.  
  237.    fprintf(printer, "%c", FF);
  238. }
  239.  
  240.  
  241.  
  242. /************************************************ close_both_files */
  243. /* This function simply closes both files.  Nothing to check.      */
  244. /*******************************************************************/
  245. void close_both_files(void)
  246. {
  247.    fclose(in_file);
  248.    fclose(printer);
  249. }
  250.